package ji

import "strings"

type node struct {
	path   string //完整路径 只有在最后一层才会标识 其他都是""
	part   string //完整路径的一部分
	isWild bool   //是模糊查询?

	children []*node //子节点们
}

// 找到一个子节点part相同的
func (n *node) matchChild(part string) *node {
	for _, child := range n.children {
		//模糊查询也可能存在用户输入part。。。
		if child.part == part || child.isWild {
			return child
		}
	}
	return nil
}

// 找到所有子节点part相同的
func (n *node) matchChildren(part string) []*node {
	nodes := make([]*node, 0)
	for _, child := range n.children {
		if child.part == part || child.isWild { //少了模糊查询的判断
			nodes = append(nodes, child)
		}
	}
	return nodes
}

//例如: /dhy/xpy/:name	-->parts = ['dhy','xpy',':name']
/*逻辑处理
当前树为 			/
	/dhy		/dhx		/dha
/xpy	/xpa
*/
/*不用height太笨了 树的插入根据深度来整
func (n *node) insert(path string, parts []string) {

	newParts := parts //copy去头
	if len(parts) == 1 {

	}
	copy(newParts[:], newParts[1:])
	if len(newParts) == 1 {

	}
	n.insert(newParts)

}
*/

// 插入 todo insert存在bug
// path 完整路径 const
// parts 路径的一部分 const
// height 当前深度
func (n *node) insert(path string, parts []string, height int) {
	//最后一个节点是递归出口
	if len(parts) == height {
		n.path = path
		return
	}

	//当前深度对应的part
	part := parts[height]
	child := n.matchChild(part)
	if child == nil {
		child = &node{
			part:   part,
			isWild: part[0] == ':' || part[0] == '*',
		}
		n.children = append(n.children, child)
	}

	//	继续下一层
	child.insert(path, parts, height+1)
}

// 查询
// parts 路径的一部分 const
// height 当前深度
func (n *node) search(parts []string, height int) *node {
	//最后一个节点或者 * 作为递归出口
	if len(parts) == height || strings.HasPrefix(n.part, "*") {
		if n.path == "" {
			return nil
		}
		return n
	}

	//当前深度对应的part
	part := parts[height]
	children := n.matchChildren(part)
	for _, child := range children {
		if res := child.search(parts, height+1); res != nil {
			return res
		}
	} //缺了+1怎么找？？？
	return nil
}
